// export function deepCopy<T>(target: T): T {
//   if (typeof target === "object") {
//     const result = (Array.isArray(target) ? [] : {}) as T;
//     for (const key in target) {
//       if (Object.prototype.hasOwnProperty.call(target, key)) {
//         if (typeof target[key] === "object" && target[key] !== null) {
//           result[key] = deepCopy(target[key]);
//         } else {
//           result[key] = target[key];
//         }
//       }
//     }

//     return result as T;
//   }

//   return target;
// }
function isObject<T>(obj: T) {
  return obj !== null && (typeof obj === "function" || typeof obj === "object");
}

export function deepCopy<T>(target: T, map = new WeakMap()): T {
  // 当value为set时，返回一个新set
  if (target instanceof Set) return new Set([...target]) as T;

  // 当target为map时，返回一个新map
  if (target instanceof Map) return new Map([...target]) as T;

  // 当target为symbol时，返回一个新symbol
  if (typeof target === "symbol") return Symbol(target.description) as T;

  // 当target为function时，直接返回原function
  if (typeof target === "function") return target;

  // 当target不为对象时，直接返回target
  if (!isObject(target)) return target;

  // 当map中存在target时，直接返回map中的target
  if (map.has(target!)) {
    return map.get(target!);
  }

  // 判断target值是否为数组，为数组时创建新的数组
  const newObj = (Array.isArray(target) ? [] : {}) as T;

  // 将函数接收到的target和新创建的obj保存到map中
  map.set(target!, newObj);

  for (let key in target) {
    // 递归处理target值
    newObj[key] = deepCopy(target[key], map);
  }

  //   // 获取symbol为key的所有数据
  //   const symbols: any = Object.getOwnPropertySymbols(target);
  //   for (let sym of symbols ) {
  //     newObj[sym] = deepCopy(target[sym], map);
  //   }
  return newObj;
}
